#pragma once
#include "board.h"


/**
* @brief Konstruktor okreslajacy wartosci domyslne pol.
*/
board::board(void)
{
	isSmtChecked=false;
	lock=false;
}
board::~board(void)
{
}


/**
* @brief Metoda zwracajaca wartosc wskazanego pola.
* @param[int x] pozycja x pola.
* @param[int y] pozycja y pola.
*/
int board::getField(int x, int y)
{
	return fldBoard[x][y].value;
}

/**
* @brief Metoda ustawiajaca wskazana wartosc, w wskazanym polu.
* @param[int value] wskazana wartosc.
* @param[int x] pozycja x pola.
* @param[int y] pozycja y pola.
*
*/
void board::setField(int value, int x, int y)
{
	fldBoard[x][y].value=value;
	
}

/**
* @brief Metoda dodajaca do wektora okreslajacego mozliwe ruchy, nowy ruch.
* @param[pos newPos] Nowa mozliwosc.
* @param[int x] pozycja x pola.
* @param[int y] pozycja y pola.
*
*/
void board::addPosMove(pos newPos, int x, int y)
{
	fldBoard[x][y].allPos.push_back(newPos);
}

/**
* @brief Metoda sprawdzajaca czy zdane pole jest zaznaczone.
* @param[int x] pozycja x pola.
* @param[int y] pozycja y pola.
*
*/
bool board::isChecked(int x, int y)
{
	if(fldBoard[x][y].isChecked)return true;
	else return false;
}

/**
* @brief Metoda zaznaczajaca wskazane pole (sprawdza czy strona jest aktualna).
* @param[int x] pozycja x pola.
* @param[int y] pozycja y pola.
* @param[int side] aktualna strona.
* @return boolean mowiacy czy pole jest zaznaczone.
*/
void board::checkField(int x, int y, int side)
{
	if(fldBoard[x][y].value==side || fldBoard[x][y].value==side+2)
	{

	
	if(fldBoard[x][y].isChecked)
	{
		if(x==checkPos.x && y==checkPos.y)
		{
		fldBoard[x][y].isChecked=false;
		lock=false;
		}

	}
	else 
	{
		if(!lock){
		fldBoard[x][y].isChecked=true;
		checkPos.x=x;
		checkPos.y=y;
		lock=true;
		}
	}}

}

/**
* @brief Metoda zwracajaca wszystkie mozliwe ruchy dla zadanego pola.
* @param[int x] pozycja x pola.
* @param[int y] pozycja y pola.
* @return vector<pos> wszystkie mozliwe ruchy.
*/
vector<pos> board::retAllPos(int x, int y)
{
	return fldBoard[x][y].allPos;
}

/**
* @brief metoda ustawiajace mozliwe ruchy np. po przefiltrowaniu.
* @param[int x] pozycja x pola.
* @param[int y] pozycja y pola.
* @param[vector<pos>newPos] nowe pozycje.
*/
void board::setAllPos(int x, int y, vector<pos>newPos)
{
	fldBoard[x][y].allPos=newPos;
}

/**
* @brief Metoda usuwajaca mozliwe ruchy dla zadanego pola lub calej planszy.
* @param[int x] pozycja x pola.
* @param[int y] pozycja y pola.
* @param[bool all] Czy wszystkie.
*/
void board::clearPos(int x, int y, bool all)
{
	if(!all)
	{
	fldBoard[x][y].allPos.clear();
	}
	else
	{
		for(int i = 0; i<8; i++)
			for(int j = 0; j<8; j++)
				clearPos(i,j,false);
	}
}

/**
* @brief Metoda zwracajaca aktualne zaznaczenie.
* @return pos wektor opisujacy pozycje.
*/
pos board::retCheck(void)
{
	return this->checkPos;
}

/**
* @brief Metoda sprawdzajaca czy plansza jest zablokowana.
* @retrun bool czy zablokowana.
*/
bool board::isLock(void)
{
	return lock;
}

/**
* @brief Metoda odblokowujaca plansze.
*/
void board::unlock(void)
{
	lock=false;
}

/**
* @brief Metoda blokujaca plansze.
*/
void board::setLock(void)
{
	this->lock=true;
}

/**
* @brief Metoda majaca za zadanie zbicie wskazanych pionow dla wskazanego piona.
* @param[int x] pozycja x pola.
* @param[int y] pozycja y pola.
* @param[int i] pozycja ofiar w wektorze opisujacym ruchy dla pola.
*/
void board::killCasualties(int x, int y, int i)
{
	int k=fldBoard[x][y].allPos[i].casualties.size();
	if(i<=fldBoard[x][y].allPos.size())
	for(int j = 0; j<k; j++)
	{
		setField(0,fldBoard[x][y].allPos[i].casualties[j].x, fldBoard[x][y].allPos[i].casualties[j].y);	
	}


}

/**
* @brief Metoda zwracajaca lokalnie najlepszy ruch dla wskazanego pola.
* @param[int x] pozycja x pola.
* @param[int y] pozycja y pola.
* @return pos pozycja potencjalnie najlepszego ruchu.
*/
pos board::retBestMove(int x, int y)
{
	vector<pos> allPos=retAllPos(x,y);
	pos newVect;

	newVect.x=-1;
	newVect.y=-1;
	newVect.level=-1;

	if(!allPos.empty())
	{
		newVect=allPos[0];

		for(int i=0; i<allPos.size(); i++)
		{
			if(allPos[i].level>newVect.level)
			{
				newVect=allPos[i];
			}
		}
		
	}
	//else
	return newVect;
	
}

/**
* @brief metoda wymuszajaca odznaczenie wszystkich pionow.
* (brute force)
*/
void board::uncheckALL(void)
{
		for(int i=0; i<8; i++)
		for(int j=0; j<8; j++)
		{
			fldBoard[i][j].isChecked=false;
		}
}
